// internal/parser/parser/alter.go
package parser

import (
	"NumberBase/internal/parser/ast"
	"NumberBase/internal/parser/lexer"
	"fmt"
)

// parseAlterTableStatement 解析ALTER TABLE语句
// 例如: ALTER TABLE users ADD COLUMN email VARCHAR NOT NULL COMMENT '用户邮箱'
// 或者: ALTER TABLE users MODIFY COLUMN name VARCHAR(100) COMMENT '用户名'
// 或者: ALTER TABLE users ADD CONSTRAINT uk_email UNIQUE (email)
func (p *Parser) parseAlterTableStatement() (*ast.AlterTableStatement, error) {
	stmt := &ast.AlterTableStatement{}

	// 跳过ALTER TABLE
	p.nextToken() // 跳过ALTER
	p.nextToken() // 跳过TABLE

	// 解析表名
	if !p.currTokenIs(lexer.IDENTIFIER) {
		return nil, fmt.Errorf("期望表名，但得到%s", p.currToken.Literal)
	}
	stmt.TableName = p.currToken.Literal
	p.nextToken()

	// 解析第一个ALTER操作
	action, err := p.parseAlterAction()
	if err != nil {
		return nil, err
	}
	stmt.Actions = append(stmt.Actions, action)

	// 如果有更多的操作（以逗号分隔），继续解析
	for p.currTokenIs(lexer.COMMA) {
		p.nextToken() // 跳过逗号
		action, err := p.parseAlterAction()
		if err != nil {
			return nil, err
		}
		stmt.Actions = append(stmt.Actions, action)
	}

	// 可选的分号
	if p.currTokenIs(lexer.SEMICOLON) {
		p.nextToken() // 跳过分号
	}

	return stmt, nil
}

// parseAlterAction 解析ALTER TABLE的具体操作
func (p *Parser) parseAlterAction() (ast.AlterAction, error) {
	action := ast.AlterAction{}

	// 根据当前Token确定操作类型
	switch p.currToken.Type {
	case lexer.ADD:
		// 检查是否是ADD COLUMN或ADD CONSTRAINT
		p.nextToken()
		if p.currTokenIs(lexer.COLUMN) {
			action.Type = ast.AddColumn
			p.nextToken() // 跳过COLUMN
			colDef, err := p.parseAlterColumnDef(false)
			if err != nil {
				return action, err
			}
			action.ColumnDef = colDef
		} else if p.currTokenIs(lexer.CONSTRAINT) {
			action.Type = ast.AddConstraint
			p.nextToken() // 跳过CONSTRAINT

			// 解析约束名称
			if !p.currTokenIs(lexer.IDENTIFIER) {
				return action, fmt.Errorf("期望约束名称，但得到%s", p.currToken.Literal)
			}
			constraintName := p.currToken.Literal
			p.nextToken()

			// 解析约束类型和定义
			constraint, err := p.parseConstraint(constraintName)
			if err != nil {
				return action, err
			}
			action.Constraint = constraint
		} else {
			return action, fmt.Errorf("ADD后期望COLUMN或CONSTRAINT，但得到%s", p.currToken.Literal)
		}

	case lexer.MODIFY:
		// MODIFY COLUMN
		action.Type = ast.ModifyColumn
		p.nextToken() // 跳过MODIFY

		// COLUMN关键字是可选的
		if p.currTokenIs(lexer.COLUMN) {
			p.nextToken() // 跳过COLUMN
		}

		colDef, err := p.parseAlterColumnDef(false)
		if err != nil {
			return action, err
		}
		action.ColumnDef = colDef

	case lexer.CHANGE:
		// CHANGE COLUMN
		action.Type = ast.ChangeColumn
		p.nextToken() // 跳过CHANGE

		// COLUMN关键字是可选的
		if p.currTokenIs(lexer.COLUMN) {
			p.nextToken() // 跳过COLUMN
		}

		colDef, err := p.parseAlterColumnDef(true)
		if err != nil {
			return action, err
		}
		action.ColumnDef = colDef

	case lexer.DROP:
		// DROP COLUMN或DROP CONSTRAINT
		p.nextToken() // 跳过DROP

		if p.currTokenIs(lexer.COLUMN) {
			action.Type = ast.DropColumn
			p.nextToken() // 跳过COLUMN

			// 解析列名
			if !p.currTokenIs(lexer.IDENTIFIER) {
				return action, fmt.Errorf("期望列名，但得到%s", p.currToken.Literal)
			}
			action.ColumnName = p.currToken.Literal
			p.nextToken() // 跳过列名
		} else if p.currTokenIs(lexer.CONSTRAINT) {
			action.Type = ast.DropConstraint
			p.nextToken() // 跳过CONSTRAINT

			// 解析约束名称
			if !p.currTokenIs(lexer.IDENTIFIER) {
				return action, fmt.Errorf("期望约束名称，但得到%s", p.currToken.Literal)
			}
			action.ConstraintName = p.currToken.Literal
			p.nextToken() // 跳过约束名称
		} else {
			return action, fmt.Errorf("DROP后期望COLUMN或CONSTRAINT，但得到%s", p.currToken.Literal)
		}

	default:
		return action, fmt.Errorf("无效的ALTER TABLE操作: %s", p.currToken.Literal)
	}

	return action, nil
}

// parseAlterColumnDef 解析列定义（用于ADD COLUMN、MODIFY COLUMN、CHANGE COLUMN）
// changeColumn为true表示是CHANGE COLUMN操作，需要解析旧列名
func (p *Parser) parseAlterColumnDef(changeColumn bool) (*ast.AlterColumnDef, error) {
	colDef := &ast.AlterColumnDef{}

	// 对于CHANGE COLUMN，先解析旧列名
	if changeColumn {
		if !p.currTokenIs(lexer.IDENTIFIER) {
			return nil, fmt.Errorf("期望旧列名，但得到%s", p.currToken.Literal)
		}
		colDef.OldName = p.currToken.Literal
		p.nextToken()
	}

	// 解析列名
	if !p.currTokenIs(lexer.IDENTIFIER) {
		return nil, fmt.Errorf("期望列名，但得到%s", p.currToken.Literal)
	}
	colDef.Name = p.currToken.Literal
	p.nextToken()

	// 解析列类型
	if !p.currTokenIs(lexer.IDENTIFIER) &&
		!p.currTokenIs(lexer.INT) &&
		!p.currTokenIs(lexer.VARCHAR) {
		return nil, fmt.Errorf("期望列类型，但得到%s", p.currToken.Literal)
	}
	colDef.Type = p.currToken.Literal
	p.nextToken()

	// 处理类型后可能的括号参数，如VARCHAR(100)
	if p.currTokenIs(lexer.LPAREN) {
		// 简单地跳过类型参数，不进行详细解析
		bracketLevel := 1
		p.nextToken() // 跳过左括号

		// 跳过括号内的所有token直到匹配的右括号
		for bracketLevel > 0 && !p.currTokenIs(lexer.EOF) {
			if p.currTokenIs(lexer.LPAREN) {
				bracketLevel++
			} else if p.currTokenIs(lexer.RPAREN) {
				bracketLevel--
			}

			if bracketLevel > 0 {
				p.nextToken()
			}
		}

		if p.currTokenIs(lexer.RPAREN) {
			p.nextToken() // 跳过右括号
		}
	}

	// 解析可选的列属性：NOT NULL、DEFAULT、COMMENT
	for p.currTokenIs(lexer.NOT) || p.currTokenIs(lexer.DEFAULT) || p.currTokenIs(lexer.COMMENT) {
		if p.currTokenIs(lexer.NOT) {
			p.nextToken() // 跳过NOT
			if !p.currTokenIs(lexer.NULL) {
				return nil, fmt.Errorf("期望NULL，但得到%s", p.currToken.Literal)
			}
			colDef.NotNull = true
			p.nextToken() // 跳过NULL
		} else if p.currTokenIs(lexer.DEFAULT) {
			p.nextToken() // 跳过DEFAULT

			// 解析默认值
			expr, err := p.parseExpression(LOWEST)
			if err != nil {
				return nil, err
			}
			colDef.Default = &ast.ColumnDefault{Value: expr}
		} else if p.currTokenIs(lexer.COMMENT) {
			p.nextToken() // 跳过COMMENT

			// COMMENT后面应该是字符串字面量
			if !p.currTokenIs(lexer.STRING) {
				return nil, fmt.Errorf("COMMENT后期望字符串，但得到%s", p.currToken.Literal)
			}
			colDef.Comment = &ast.ColumnComment{Text: p.currToken.Literal}
			p.nextToken() // 跳过注释字符串
		}
	}

	return colDef, nil
}

// parseConstraint 解析约束定义
func (p *Parser) parseConstraint(name string) (*ast.Constraint, error) {
	constraint := &ast.Constraint{
		Name: name,
	}

	// 解析约束类型
	switch p.currToken.Type {
	case lexer.UNIQUE:
		constraint.Type = ast.UniqueConstraint
		p.nextToken() // 跳过UNIQUE

		// 解析列名列表
		if !p.currTokenIs(lexer.LPAREN) {
			return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
		}

		columns, err := p.parseIdentifierList()
		if err != nil {
			return nil, err
		}
		constraint.Columns = columns

		// 此时已经跳过了右括号，不需要再处理

	case lexer.PRIMARY:
		constraint.Type = ast.PrimaryKeyConstraint
		p.nextToken() // 跳过PRIMARY

		if !p.currTokenIs(lexer.KEY) {
			return nil, fmt.Errorf("期望KEY，但得到%s", p.currToken.Literal)
		}
		p.nextToken() // 跳过KEY

		// 解析列名列表
		if !p.currTokenIs(lexer.LPAREN) {
			return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
		}

		columns, err := p.parseIdentifierList()
		if err != nil {
			return nil, err
		}
		constraint.Columns = columns

		// 此时已经跳过了右括号，不需要再处理

	case lexer.FOREIGN:
		constraint.Type = ast.ForeignKeyConstraint
		p.nextToken() // 跳过FOREIGN

		if !p.currTokenIs(lexer.KEY) {
			return nil, fmt.Errorf("期望KEY，但得到%s", p.currToken.Literal)
		}
		p.nextToken() // 跳过KEY

		// 解析列名列表
		if !p.currTokenIs(lexer.LPAREN) {
			return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
		}

		columns, err := p.parseIdentifierList()
		if err != nil {
			return nil, err
		}
		constraint.Columns = columns

		// 期望REFERENCES关键字
		if !p.currTokenIs(lexer.REFERENCES) {
			return nil, fmt.Errorf("期望REFERENCES，但得到%s", p.currToken.Literal)
		}
		p.nextToken() // 跳过REFERENCES

		// 解析被引用表名
		if !p.currTokenIs(lexer.IDENTIFIER) {
			return nil, fmt.Errorf("期望表名，但得到%s", p.currToken.Literal)
		}
		constraint.ReferencedTable = p.currToken.Literal
		p.nextToken() // 跳过表名

		// 解析被引用列名列表
		if !p.currTokenIs(lexer.LPAREN) {
			return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
		}

		refColumns, err := p.parseIdentifierList()
		if err != nil {
			return nil, err
		}
		constraint.ReferencedCols = refColumns

		// 此时已经跳过了右括号，不需要再处理

	default:
		return nil, fmt.Errorf("不支持的约束类型: %s", p.currToken.Literal)
	}

	return constraint, nil
}
